home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Pascal / Utilities / MandelNet / messaging.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-14  |  8.7 KB  |  429 lines  |  [TEXT/KAHL]
  1. #include "mandel.h"
  2.  
  3.  
  4.  
  5. SetupAppleTalk()
  6. {
  7. int        errCode;
  8.  
  9.     SetCursor(&waitCursor);
  10.     
  11.     errCode = InitAppleTalk();
  12.     
  13.     if (errCode == 0)
  14.     {
  15.         GetNodeAddress(&myNode,&myNet);
  16.         sprintf(myName," MandelNet Node #%d",myNode);
  17.         
  18.         strcpy(myEntity.objStr,myName);
  19.         CtoPstr((char *) myEntity.objStr);
  20.         
  21.         if (slaveMode)
  22.             strcpy(myEntity.typeStr,slaveSig);
  23.         else
  24.             strcpy(myEntity.typeStr,masterSig);
  25.         
  26.         CtoPstr((char *) myEntity.typeStr);
  27.         strcpy(myEntity.zoneStr,"*");
  28.         CtoPstr((char *) myEntity.zoneStr);
  29.         
  30.         errCode = RegisterName();
  31.     }
  32.     
  33.     InitCursor();
  34.     
  35.     return(errCode);
  36. }
  37.  
  38.  
  39.  
  40. InitAppleTalk()
  41. {
  42. AddrBlock        theAddrBlock;
  43.     
  44.     DisplayMessage("Checking AppleTalk");
  45.     
  46.     SetCursor(&waitCursor);
  47.     
  48.     errCode = ATPLoad();
  49.     
  50.     if (errCode != noErr)
  51.         ErrorMessage("ATPLoad",errCode);
  52.     
  53.     else
  54.     {
  55.         theAddrBlock.aNet = 0;
  56.         theAddrBlock.aNode = 0;
  57.         theAddrBlock.aSocket = 0;
  58.         
  59.         mySocket = 0;
  60.         
  61.         DisplayMessage("Opening AppleTalk socket");
  62.         
  63.         errCode = ATPOpenSocket(theAddrBlock,&mySocket);
  64.         
  65.         if (errCode != noErr)
  66.             ErrorMessage("ATPOpenSocket",errCode);
  67.         else
  68.             DisplayMessage("AppleTalk socket opened successfully");
  69.     }
  70.     
  71.     InitCursor();
  72.     
  73.     return(errCode);
  74. }
  75.  
  76.  
  77.  
  78. ShutDownAppleTalk()
  79. {
  80. int        errCode = noErr;
  81.  
  82.     SetCursor(&waitCursor);
  83.     
  84.     if (nbpRegistered)    /* Are we registered? */
  85.     {
  86.         UnRegisterName();    /*    Go remove our name from the NBP table */
  87.         
  88.         errCode = ATPCloseSocket(mySocket);        /* Close the socket */
  89.         
  90.         if (errCode != noErr)
  91.             ErrorMessage("ATPCloseSocket",errCode);    /* Oops! Notify the user of the error */
  92.     }
  93.     
  94.     InitCursor();
  95.     
  96.     return(errCode);
  97. }
  98.  
  99.  
  100.  
  101. RegisterName()
  102. {
  103. ABRecHandle        nbpRecord;
  104.     
  105.     SetCursor(&waitCursor);
  106.     
  107.     if (nbpRegistered==FALSE)
  108.     {
  109.         nbpRecord = (ABRecHandle) NewHandle(nbpSize);
  110.         nbpName = NewPtr(nbpNameBufSize);
  111.         
  112.         (**nbpRecord).nbpProto.nbpEntityPtr = &myEntity;
  113.         (**nbpRecord).nbpProto.nbpBufPtr = nbpName;
  114.         (**nbpRecord).nbpProto.nbpBufSize = nbpNameBufSize;
  115.         (**nbpRecord).nbpProto.nbpAddress.aSocket = mySocket;
  116.         (**nbpRecord).nbpProto.nbpRetransmitInfo.retransInterval = rtInterval;
  117.         (**nbpRecord).nbpProto.nbpRetransmitInfo.retransCount = rtCount;
  118.         
  119.         DisplayMessage("Registering on AppleTalk");
  120.         
  121.         errCode = NBPRegister(nbpRecord,FALSE);
  122.         
  123.         if (errCode != noErr)
  124.         {
  125.             nbpRegistered = FALSE;
  126.             DisposPtr(nbpName);
  127.             
  128.             ErrorMessage("NBPRegister",errCode);
  129.         }
  130.         else
  131.         {
  132.             nbpRegistered = TRUE;
  133.             
  134.             DisplayMessage("Registered on AppleTalk");
  135.         }
  136.         
  137.         DisposHandle(nbpRecord);
  138.     }
  139.     
  140.     else
  141.     {
  142.         DisplayMessage("Redundant attempt to register on AppleTalk");
  143.         errCode = noErr;
  144.     }
  145.     
  146.     InitCursor();
  147.     
  148.     return(errCode);
  149. }
  150.  
  151.  
  152.  
  153.  
  154. UnRegisterName()
  155. {
  156. int    errCode;
  157.     
  158.     SetCursor(&waitCursor);
  159.     
  160.     if (nbpRegistered == TRUE)
  161.     {
  162.         DisplayMessage("Removing node from AppleTalk");
  163.         
  164.         errCode = NBPRemove(&myEntity);
  165.         
  166.         if (errCode != noErr)
  167.             ErrorMessage("NBPRemove",errCode);
  168.         else
  169.             DisplayMessage("Node removed from AppleTalk");
  170.         
  171.         DisposPtr(nbpName);
  172.         nbpName = 0L;
  173.         
  174.         nbpRegistered = FALSE;
  175.     }
  176.     else
  177.     {
  178.         DisplayMessage("Redundant attempt to unregister from AppleTalk");
  179.         errCode = noErr;
  180.     }
  181.     
  182.     InitCursor();
  183.     
  184.     return(errCode);
  185. }
  186.  
  187.  
  188.  
  189. LookupSlaves()
  190. {
  191. int                i;
  192. EntityName        theEntity;
  193. AddrBlock        theAddrBlock;
  194. ABRecHandle        nbpRecord;
  195. char            tempString[256];
  196.  
  197.     SetCursor(&waitCursor);
  198.     
  199.     nbpRecord = (ABRecHandle) NewHandle(nbpSize);
  200.     
  201.     numSlaves = 0;
  202.     
  203.     strcpy(theEntity.objStr,"=");
  204.     CtoPstr((char *) theEntity.objStr);
  205.     strcpy(theEntity.typeStr,slaveSig);
  206.     CtoPstr((char *) theEntity.typeStr);
  207.     strcpy(theEntity.zoneStr,"*");
  208.     CtoPstr((char *) theEntity.zoneStr);
  209.     
  210.      (**nbpRecord).nbpProto.nbpEntityPtr = &theEntity;
  211.     (**nbpRecord).nbpProto.nbpBufPtr = (Ptr) myBuffer;
  212.     (**nbpRecord).nbpProto.nbpBufSize = myBufSize;
  213.     (**nbpRecord).nbpProto.nbpDataField = maxSlaves;
  214.     (**nbpRecord).nbpProto.nbpAddress.aSocket = mySocket;
  215.     (**nbpRecord).nbpProto.nbpRetransmitInfo.retransInterval = rtInterval;
  216.     (**nbpRecord).nbpProto.nbpRetransmitInfo.retransCount = rtCount;
  217.     
  218.     DisplayMessage("Looking for nodes on AppleTalk");
  219.     
  220.     errCode = NBPLookup(nbpRecord,FALSE);
  221.     
  222.     if (errCode == noErr) 
  223.     {
  224.         numSlaves = (**nbpRecord).nbpProto.nbpDataField;
  225.         
  226.         if (numSlaves)
  227.         {
  228.             for (i=1;i<=numSlaves && i<=maxSlaves && errCode==noErr;i++)
  229.             {
  230.                 sprintf(tempString,"Extracting info for entry #%d",i);
  231.                 DisplayMessage(tempString);
  232.                 
  233.                 errCode = NBPExtract(myBuffer,numSlaves,i,&theEntity,&theAddrBlock);
  234.                 
  235.                 if (errCode != noErr)
  236.                     ErrorMessage("NBPExtract",errCode);
  237.                 
  238.                 slaveNet[i-1] = theAddrBlock.aNet;
  239.                 slaveNode[i-1] = theAddrBlock.aNode;
  240.                 slaveSocket[i-1] = theAddrBlock.aSocket;
  241.             }
  242.             
  243.             if (errCode==noErr && numSlaves>maxSlaves)
  244.             {
  245.                 DisplayMessage("Too many nodes found-- restricting number used");
  246.                 
  247.                 numSlaves = maxSlaves;
  248.             }
  249.         }
  250.     }
  251.     
  252.     else
  253.         ErrorMessage("NBPLookup",errCode);
  254.     
  255.     DisposHandle(nbpRecord);
  256.     
  257.     InitCursor();
  258.     
  259.     return(errCode);
  260. }
  261.  
  262.  
  263.  
  264.  
  265.  
  266. AwaitRequest(receiveRecord,messagePtr)
  267. ABRecHandle    receiveRecord;slaveMessage    *messagePtr;
  268. {
  269.     (**receiveRecord).atpProto.atpSocket = mySocket;    
  270.     (**receiveRecord).atpProto.atpReqCount = sizeof(slaveMessage);
  271.     (**receiveRecord).atpProto.atpDataPtr = (Ptr) messagePtr;
  272.     
  273.     errCode = ATPGetRequest(receiveRecord,TRUE);
  274.     
  275.     if (errCode != noErr)
  276.         ErrorMessage("ATPGetRequest",errCode);
  277.     
  278.     return(errCode);
  279. }
  280.  
  281.  
  282.  
  283.  
  284. KillRequest()
  285. {
  286. int        errCode;
  287.  
  288.     SetCursor(&waitCursor);
  289.     
  290.     errCode = UnRegisterName();
  291.     
  292.     if (errCode == noErr)
  293.     {
  294.         errCode = ATPCloseSocket(mySocket);
  295.         
  296.         if (errCode != noErr)
  297.             ErrorMessage("ATPCloseSocket",errCode);
  298.     }
  299.     
  300.     InitCursor();
  301.     
  302.     return(errCode);
  303. }
  304.  
  305.  
  306.  
  307.  
  308. RespondToRequest(receiveRecord)
  309. ABRecHandle        receiveRecord;
  310. {
  311. slaveMessage    *messagePtr;
  312. int                errCode,firstRow,lastRow;
  313. BitMap            mandelBits;
  314. int                bitmapSize;
  315.  
  316.     messagePtr = (slaveMessage *) (**receiveRecord).atpProto.atpDataPtr;
  317.     
  318.     switch ((**receiveRecord).atpProto.atpUserData)
  319.     {
  320.         case workOrder:
  321.             lims[xmin] = messagePtr->lims[xmin];
  322.             lims[xmax] = messagePtr->lims[xmax];
  323.             lims[ymin] = messagePtr->lims[ymin];
  324.             lims[ymax] = messagePtr->lims[ymax];
  325.             
  326.             maxIterations = messagePtr->maxIterations;
  327.             pixelSize = messagePtr->pixelSize;
  328.             shading = messagePtr->shading;
  329.             DrawInfo();
  330.             
  331.             firstRow = messagePtr->firstRow;
  332.             lastRow = messagePtr->lastRow;
  333.             
  334.             DisplayMessage("Confirming workOrder");
  335.             
  336.             (**receiveRecord).atpProto.atpRspUData = confirmOrder;
  337.             
  338.             (**receiveRecord).atpProto.atpSocket = mySocket;
  339.             (**receiveRecord).atpProto.atpRspBuf = 0L;
  340.             (**receiveRecord).atpProto.atpRspSize = 0;
  341.     
  342.             errCode = ATPResponse(receiveRecord,FALSE);
  343.             
  344.             if (errCode != noErr)
  345.                 ErrorMessage("ATPResponse",errCode);
  346.             
  347.             AwaitRequest(receiveRecord,&theMessage);
  348.             
  349.             DisplayMessage("Generating assigned Mandelbrot region");
  350.             SetCursor(&waitCursor);
  351.             Mandelbrot(firstRow,lastRow);
  352.             
  353.             CopyBits(&(theWPtr->portBits),&graphBits,&graphRect,&graphRect,srcCopy,0L);
  354.             
  355.             DisplayMessage("Completed assigned Mandelbrot region");
  356.             
  357.             InitCursor();
  358.             
  359.             break;
  360.             
  361.         case bitmapRequest:
  362.             DisplayMessage("Sending bitmap");
  363.             
  364.             mandelBits.bounds.left = graphRect.left+1;
  365.             mandelBits.bounds.right = graphRect.right-1;
  366.             mandelBits.bounds.top = messagePtr->firstRow;
  367.             mandelBits.bounds.bottom = messagePtr->lastRow;
  368.             
  369.             mandelBits.rowBytes = (mandelBits.bounds.right - mandelBits.bounds.left + 1)/8;
  370.             if (mandelBits.rowBytes & 1) mandelBits.rowBytes++;
  371.             
  372.             bitmapSize = mandelBits.rowBytes * (mandelBits.bounds.bottom - mandelBits.bounds.top + 1);
  373.             
  374.             mandelBits.baseAddr = NewPtr(bitmapSize);
  375.             
  376.             CopyBits(&(theWPtr->portBits),&mandelBits,&(mandelBits.bounds),&(mandelBits.bounds),srcCopy,0L);
  377.             
  378.             (**receiveRecord).atpProto.atpRspUData = bitmapResponse;
  379.             (**receiveRecord).atpProto.atpSocket = mySocket;
  380.             (**receiveRecord).atpProto.atpRspBuf = mandelBits.baseAddr;
  381.             (**receiveRecord).atpProto.atpRspSize = bitmapSize;
  382.     
  383.             errCode = ATPResponse(receiveRecord,FALSE);
  384.             
  385.             if (errCode != noErr)
  386.                 ErrorMessage("ATPResponse",errCode);
  387.                 
  388.             DisposPtr(mandelBits.baseAddr);
  389.             
  390.             break;
  391.         
  392.         case stopOrder:
  393.             DisplayMessage("Confirming stopOrder");
  394.             
  395.             (**receiveRecord).atpProto.atpRspUData = confirmOrder;
  396.             
  397.             (**receiveRecord).atpProto.atpSocket = mySocket;
  398.             (**receiveRecord).atpProto.atpRspBuf = 0L;
  399.             (**receiveRecord).atpProto.atpRspSize = 0;
  400.     
  401.             errCode = ATPResponse(receiveRecord,FALSE);
  402.             
  403.             if (errCode != noErr)
  404.                 ErrorMessage("ATPResponse",errCode);
  405.             
  406.             break;
  407.             
  408.         case queryStatus:
  409.             DisplayMessage("Reporting idle status");
  410.             
  411.             (**receiveRecord).atpProto.atpRspUData = idleResponse;
  412.             
  413.             (**receiveRecord).atpProto.atpSocket = mySocket;
  414.             (**receiveRecord).atpProto.atpRspBuf = 0L;
  415.             (**receiveRecord).atpProto.atpRspSize = 0;
  416.     
  417.             errCode = ATPResponse(receiveRecord,FALSE);
  418.             
  419.             if (errCode != noErr)
  420.                 ErrorMessage("ATPResponse",errCode);
  421.             
  422.             break;
  423.             
  424.         default:
  425.             errCode = noErr;
  426.     }
  427.     
  428.     return(errCode);
  429. }